package com.yc.services;

import com.alibaba.nacos.common.utils.StringUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yc.bean.Product;
import com.yc.mapper.ProductMapper;
import com.yc.web.DTO.ProductDTO;
import com.yc.web.clients.IdGeneratorClient;
import com.yc.web.clients.OSSClient;
import com.yc.web.controller.model.ResponseResult;
import lombok.extern.java.Log;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.math.BigDecimal;
import java.util.List;
import java.util.stream.Collectors;

@Service
@Log
public class ProductServiceImpl implements ProductService {
    @Autowired
    private ProductMapper productMapper;

    @Autowired
    private IdGeneratorClient idGeneratorClient;
    @Autowired
    private OSSClient ossClient;

    /**
     * 分页查询商品
     * @param queryVO 查询参数，包含商品名称、分类ID、商品状态、排序方式等
     * @return 商品DTO的分页结果
     */
    @Override
    public IPage<ProductDTO> listProductsPaged(ProductQueryVO queryVO) {
        //使用传入的当前页和每页大小创建MyBatis-Plus分页对象
        //MyBatis-Plus会自动将此对象转换为SQL的LIMIT语句
        Page<Product> page = new Page<>(queryVO.getCurrent(), queryVO.getSize());

        // 构建查询条件
        LambdaQueryWrapper<Product> queryWrapper = new LambdaQueryWrapper<>();

        // 根据商品名称模糊查询
        if (StringUtils.hasText(queryVO.getProductName())) {
            queryWrapper.like(Product::getProductName, queryVO.getProductName());
        }
        // 根据分类ID精确查询
        if (queryVO.getCategoryId() != null) {
            queryWrapper.eq(Product::getCategoryId, queryVO.getCategoryId());
        }
        // 根据商品状态查询
        if (queryVO.getProductStatus() != null) {
            queryWrapper.eq(Product::getProductStatus, queryVO.getProductStatus());
        }

        // 处理排序
        if (StringUtils.hasText(queryVO.getSortField())) {
            boolean isAsc = !"desc".equalsIgnoreCase(queryVO.getSortOrder());
            switch (queryVO.getSortField().toLowerCase()) {
                case "price":
                    queryWrapper.orderBy(true, isAsc, Product::getPrice);
                    break;
                case "productId":
                    queryWrapper.orderBy(true, isAsc, Product::getProductId);
                    break;
                // 可以添加其他排序字段
                default:
                    // 默认按商品ID降序
                    queryWrapper.orderByDesc(Product::getProductStatus);
                    break;
            }
        } else {
            // 默认排序
            queryWrapper.orderByDesc(Product::getProductId);
        }
        // 执行分页查询
        // MyBatis-Plus会组合分页参数和查询条件生成SQL
        IPage<Product> productPage = productMapper.selectPage(page, queryWrapper);
//        执行类似这样的SQL：
//        sql
//        SELECT * FROM product
//        WHERE product_name LIKE '%关键字%'
//        AND category_id = 1
//        ORDER BY price ASC
//        LIMIT 0, 10
        // 将实体分页结果转换为DTO分页结果
        return productPage.convert(product -> {
            ProductDTO dto = new ProductDTO();
            BeanUtils.copyProperties(product, dto);
            // 这里可以添加从其他服务获取分类名称的逻辑，例如通过Feign调用分类服务
            // dto.setCategoryName(categoryService.getCategoryNameById(product.getCategoryId()));
            return dto;
        });
    }

    /**
     * 上架商品 (新增商品)
     * @param productDTO 待上架的商品信息
     * @return 上架成功后的商品DTO
     */
    @Override
    @Transactional // 开启事务
    public ProductDTO addProduct(ProductDTO productDTO) {
        log.info("添加商品："+productDTO);
        // 1. 生成商品ID
        ResponseResult rr= this.idGeneratorClient.getNextId();
        if(  rr.getCode()!=1){
            throw new RuntimeException("商品ID生成失败");
        }
        Long productId =Long.parseLong(rr.getData().toString());
        productDTO.setProductId(productId);

        // 2. 模拟图片上传并设置URL
        //if (StringUtils.hasText(productDTO.getMainImage())) {
        ResponseResult rr2= this.ossClient.uploadFile(   new MultipartFile[]{ productDTO.getMainImageFile() });
        if(  rr2.getCode()!=1){
            throw new RuntimeException("商品主图片上传失败");
        }
        List<String> mainImages= (List<String>) rr2.getData();
        productDTO.setMainImage(   mainImages.get(0)  );
        // }
        //  if (StringUtils.hasText(productDTO.getSubImages())) {
        // 假设subImages是逗号分隔的图片数据，这里需要循环上传
        MultipartFile[] subImageFiles = productDTO.getSubImageFiles();
        ResponseResult rr3= this.ossClient.uploadFile(   subImageFiles );

        List<String> subImages= (List<String>) rr3.getData();
        StringBuilder uploadedSubImages = new StringBuilder();
        for (String imgData : subImages) {
            if (StringUtils.hasText(imgData)) {
                uploadedSubImages.append(imgData).append(",");
            }
        }
        if (uploadedSubImages.length() > 0) {
            uploadedSubImages.setLength(uploadedSubImages.length() - 1); // 移除最后一个逗号
        }
        productDTO.setSubImages(uploadedSubImages.toString());
        //  }
        // 3. 设置默认状态为上架
        if (productDTO.getProductStatus() == null) {
            productDTO.setProductStatus(1); // 默认上架
        }
        // 4. 确保价格不为空
        if (productDTO.getPrice() == null) {
            productDTO.setPrice(BigDecimal.ZERO);
        }
        // 5. 将DTO转换为实体
        Product product = new Product();
        BeanUtils.copyProperties(productDTO, product);
        // 6. 插入数据库
        int result = productMapper.insert(product);
        if (result > 0) {
            // 插入成功后，返回包含完整信息的DTO
            BeanUtils.copyProperties(product, productDTO);
            return productDTO;
        } else {
            throw new RuntimeException("商品上架失败");
        }
    }

    /**
     * 下架商品
     * @param productId 商品ID
     * @return 是否下架成功
     */
    @Override
    @Transactional
    public boolean delistProduct(Long productId) {
        // 构建更新条件，只更新状态
        LambdaUpdateWrapper<Product> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(Product::getProductId, productId)
                .set(Product::getProductStatus, 0); // 0-下架

        int result = productMapper.update(null, updateWrapper);
        return result > 0;
    }

    /**
     * 更新商品信息
     * @param productDTO 待更新的商品信息
     * @return 更新成功后的商品DTO
     */
    @Override
    @Transactional
    public ProductDTO updateProduct(ProductDTO productDTO) {
        if (productDTO.getProductId() == null) {
            throw new IllegalArgumentException("商品ID不能为空，无法更新");
        }

        if( productDTO.getMainImageFile()!=null ) {
            ResponseResult rr2 = this.ossClient.uploadFile(new MultipartFile[]{productDTO.getMainImageFile()});
            if (rr2.getCode() != 1) {
                throw new RuntimeException("商品主图片上传失败");
            }
            List<String> mainImages = (List<String>) rr2.getData();
            productDTO.setMainImage(mainImages.get(0));
        }

        if( productDTO.getSubImageFiles()!=null && productDTO.getSubImageFiles().length>0) {
            // 假设subImages是逗号分隔的图片数据，这里需要循环上传
            MultipartFile[] subImageFiles = productDTO.getSubImageFiles();
            ResponseResult rr3 = this.ossClient.uploadFile(subImageFiles);
            List<String> subImages= (List<String>) rr3.getData();
            StringBuilder uploadedSubImages = new StringBuilder();
            for (String imgData : subImages) {
                if (StringUtils.hasText(imgData)) {
                    uploadedSubImages.append(imgData).append(",");
                }
            }
            if (uploadedSubImages.length() > 0) {
                uploadedSubImages.setLength(uploadedSubImages.length() - 1); // 移除最后一个逗号
            }
            productDTO.setSubImages(uploadedSubImages.toString());
        }

        // 将DTO转换为实体
        Product product = new Product();
        BeanUtils.copyProperties(productDTO, product);

        // 执行更新，MyBatis Plus会根据实体中的@TableId注解自动识别主键
        int result = productMapper.updateById(product);
        if (result > 0) {
            // 更新成功后，返回最新的商品信息
            return getProductById(productDTO.getProductId());
        } else {
            throw new RuntimeException("商品更新失败，商品ID: " + productDTO.getProductId());
        }
    }

    /**
     * 根据商品ID获取商品详情
     * @param productId 商品ID
     * @return 商品DTO
     */
    @Override
    public ProductDTO getProductById(Long productId) {
        Product product = productMapper.selectById(productId);
        if (product == null) {
            return null;
        }
        ProductDTO dto = new ProductDTO();
        BeanUtils.copyProperties(product, dto);
        return dto;
    }

    /**
     * 查询特价商品（原价小于现价）且上架的商品列表
     * @param current 页码
     * @param size 每页大小
     * @return 特价商品的分页结果
     */
    @Override
    public IPage<ProductDTO> listDiscountedProducts(int current, int size) {
        Page<Product> page = new Page<>(current, size);

        // 替换 LambdaQueryWrapper 为 QueryWrapper
        QueryWrapper<Product> queryWrapper = new QueryWrapper<>();
        queryWrapper
                .eq("productStatus", 1)
                .apply("originalPrice > price")  // 关键：字段之间比较
                .orderByDesc("productId");

        IPage<Product> productPage = productMapper.selectPage(page, queryWrapper);

        return productPage.convert(product -> {
            ProductDTO dto = new ProductDTO();
            BeanUtils.copyProperties(product, dto);
            return dto;
        });
    }

    /**
     * 根据类别ID分页查询商品（仅查询上架状态）
     * @param categoryId 类别ID
     * @param current 页码
     * @param size 每页大小
     * @return 商品分页结果
     */
    @Override
    public IPage<ProductDTO> listProductsByCategory(String categoryId, int current, int size) {
        Page<Product> page = new Page<>(current, size);

        QueryWrapper<Product> queryWrapper = new QueryWrapper<>();
        queryWrapper
                .eq("categoryId", categoryId)
                .eq("productStatus", 1) // 只查询上架商品
                .orderByDesc("productId"); // 按ID降序

        IPage<Product> productPage = productMapper.selectPage(page, queryWrapper);

        return productPage.convert(product -> {
            ProductDTO dto = new ProductDTO();
            BeanUtils.copyProperties(product, dto);
            return dto;
        });
    }

}
